// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.logistics.withdraw;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.LogisticsWithdraw;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(LogisticsWithdraw.class)
@Setter
@Getter
public class LogisticsWithdrawSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "LogisticsWithdraw".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("receivingWarehouse", "w");
    map.put("feeRecorder", "su");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：LogisticsWithdraw/Alllnb, LogisticsWithdraw/Unpaid, LogisticsWithdraw/PaidOff
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 物流商(模糊搜索)
   */
  private String logisticsProvider;

  /**
   * 物流商 比较(eq)
   */
  private String logisticsProviderEq;
  /**
   * 物流商 比较(neq)
   */
  private String logisticsProviderNeq;
  /**
   * 物流商 比较(gt)
   */
  private String logisticsProviderGt;
  /**
   * 物流商 比较(gte)
   */
  private String logisticsProviderGte;
  /**
   * 物流商 比较(lt)
   */
  private String logisticsProviderLt;
  /**
   * 物流商 比较(lte)
   */
  private String logisticsProviderLte;
  /**
   * 物流商 比较(contains)
   */
  private String logisticsProviderContains;
  /**
   * 物流商 比较(notcontains)
   */
  private String logisticsProviderNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private String logisticsProviderStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private String logisticsProviderEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean logisticsProviderIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean logisticsProviderIsnotnull;

  /**
   * 物流商(精确搜索)
   */
  private List<String> logisticsProviderInList;

  /**
   * 发货单号(模糊搜索)
   */
  private String inoviceCode;

  /**
   * 发货单号 比较(eq)
   */
  private String inoviceCodeEq;
  /**
   * 发货单号 比较(neq)
   */
  private String inoviceCodeNeq;
  /**
   * 发货单号 比较(gt)
   */
  private String inoviceCodeGt;
  /**
   * 发货单号 比较(gte)
   */
  private String inoviceCodeGte;
  /**
   * 发货单号 比较(lt)
   */
  private String inoviceCodeLt;
  /**
   * 发货单号 比较(lte)
   */
  private String inoviceCodeLte;
  /**
   * 发货单号 比较(contains)
   */
  private String inoviceCodeContains;
  /**
   * 发货单号 比较(notcontains)
   */
  private String inoviceCodeNotcontains;
  /**
   * 发货单号 比较(startswith)
   */
  private String inoviceCodeStartswith;
  /**
   * 发货单号 比较(endswith)
   */
  private String inoviceCodeEndswith;
  /**
   * 发货单号 比较(isnull)
   */
  private Boolean inoviceCodeIsnull;
  /**
   * 发货单号 比较(isnotnull)
   */
  private Boolean inoviceCodeIsnotnull;

  /**
   * 发货单号(精确搜索)
   */
  private List<String> inoviceCodeInList;

  /**
   * 品名(模糊搜索)
   */
  private String productName;

  /**
   * 品名 比较(eq)
   */
  private String productNameEq;
  /**
   * 品名 比较(neq)
   */
  private String productNameNeq;
  /**
   * 品名 比较(gt)
   */
  private String productNameGt;
  /**
   * 品名 比较(gte)
   */
  private String productNameGte;
  /**
   * 品名 比较(lt)
   */
  private String productNameLt;
  /**
   * 品名 比较(lte)
   */
  private String productNameLte;
  /**
   * 品名 比较(contains)
   */
  private String productNameContains;
  /**
   * 品名 比较(notcontains)
   */
  private String productNameNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private String productNameStartswith;
  /**
   * 品名 比较(endswith)
   */
  private String productNameEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;

  /**
   * 品名(精确搜索)
   */
  private List<String> productNameInList;

  /**
   * 物流商单号(模糊搜索)
   */
  private String logisticsProvidercode;

  /**
   * 物流商单号 比较(eq)
   */
  private String logisticsProvidercodeEq;
  /**
   * 物流商单号 比较(neq)
   */
  private String logisticsProvidercodeNeq;
  /**
   * 物流商单号 比较(gt)
   */
  private String logisticsProvidercodeGt;
  /**
   * 物流商单号 比较(gte)
   */
  private String logisticsProvidercodeGte;
  /**
   * 物流商单号 比较(lt)
   */
  private String logisticsProvidercodeLt;
  /**
   * 物流商单号 比较(lte)
   */
  private String logisticsProvidercodeLte;
  /**
   * 物流商单号 比较(contains)
   */
  private String logisticsProvidercodeContains;
  /**
   * 物流商单号 比较(notcontains)
   */
  private String logisticsProvidercodeNotcontains;
  /**
   * 物流商单号 比较(startswith)
   */
  private String logisticsProvidercodeStartswith;
  /**
   * 物流商单号 比较(endswith)
   */
  private String logisticsProvidercodeEndswith;
  /**
   * 物流商单号 比较(isnull)
   */
  private Boolean logisticsProvidercodeIsnull;
  /**
   * 物流商单号 比较(isnotnull)
   */
  private Boolean logisticsProvidercodeIsnotnull;

  /**
   * 物流商单号(精确搜索)
   */
  private List<String> logisticsProvidercodeInList;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 收货仓库
   */
  private Long receivingWarehouse;

  /**
   * 收货仓库 比较(eq)
   */
  private Long receivingWarehouseEq;
  /**
   * 收货仓库 比较(neq)
   */
  private Long receivingWarehouseNeq;
  /**
   * 收货仓库 比较(gt)
   */
  private Long receivingWarehouseGt;
  /**
   * 收货仓库 比较(gte)
   */
  private Long receivingWarehouseGte;
  /**
   * 收货仓库 比较(lt)
   */
  private Long receivingWarehouseLt;
  /**
   * 收货仓库 比较(lte)
   */
  private Long receivingWarehouseLte;
  /**
   * 收货仓库 比较(contains)
   */
  private Long receivingWarehouseContains;
  /**
   * 收货仓库 比较(notcontains)
   */
  private Long receivingWarehouseNotcontains;
  /**
   * 收货仓库 比较(startswith)
   */
  private Long receivingWarehouseStartswith;
  /**
   * 收货仓库 比较(endswith)
   */
  private Long receivingWarehouseEndswith;
  /**
   * 收货仓库 比较(isnull)
   */
  private Boolean receivingWarehouseIsnull;
  /**
   * 收货仓库 比较(isnotnull)
   */
  private Boolean receivingWarehouseIsnotnull;
  /**
   * 收货仓库的仓库名称 比较(eq)
   */
  private String receivingWarehouseNameEq;
  /**
   * 收货仓库的仓库名称 比较(neq)
   */
  private String receivingWarehouseNameNeq;
  /**
   * 收货仓库的仓库名称 比较(gt)
   */
  private String receivingWarehouseNameGt;
  /**
   * 收货仓库的仓库名称 比较(gte)
   */
  private String receivingWarehouseNameGte;
  /**
   * 收货仓库的仓库名称 比较(lt)
   */
  private String receivingWarehouseNameLt;
  /**
   * 收货仓库的仓库名称 比较(lte)
   */
  private String receivingWarehouseNameLte;
  /**
   * 收货仓库的仓库名称 比较(contains)
   */
  private String receivingWarehouseNameContains;
  /**
   * 收货仓库的仓库名称 比较(notcontains)
   */
  private String receivingWarehouseNameNotcontains;
  /**
   * 收货仓库的仓库名称 比较(startswith)
   */
  private String receivingWarehouseNameStartswith;
  /**
   * 收货仓库的仓库名称 比较(endswith)
   */
  private String receivingWarehouseNameEndswith;
  /**
   * 收货仓库的仓库名称 比较(isnull)
   */
  private Boolean receivingWarehouseNameIsnull;
  /**
   * 收货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean receivingWarehouseNameIsnotnull;

  /**
   * 收货仓库(范围搜索)
   */
  private List<Long> receivingWarehouseInList;

  /**
   * 物流方式
   */
  private String logisticsMode;

  /**
   * 物流方式 比较(eq)
   */
  private String logisticsModeEq;
  /**
   * 物流方式 比较(neq)
   */
  private String logisticsModeNeq;
  /**
   * 物流方式 比较(gt)
   */
  private String logisticsModeGt;
  /**
   * 物流方式 比较(gte)
   */
  private String logisticsModeGte;
  /**
   * 物流方式 比较(lt)
   */
  private String logisticsModeLt;
  /**
   * 物流方式 比较(lte)
   */
  private String logisticsModeLte;
  /**
   * 物流方式 比较(contains)
   */
  private String logisticsModeContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private String logisticsModeNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private String logisticsModeStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private String logisticsModeEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean logisticsModeIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean logisticsModeIsnotnull;

  /**
   * 物流方式(精确搜索)
   */
  private List<String> logisticsModeInList;

  /**
   * 费用类型
   */
  private String feeType;

  /**
   * 费用类型 比较(eq)
   */
  private String feeTypeEq;
  /**
   * 费用类型 比较(neq)
   */
  private String feeTypeNeq;
  /**
   * 费用类型 比较(gt)
   */
  private String feeTypeGt;
  /**
   * 费用类型 比较(gte)
   */
  private String feeTypeGte;
  /**
   * 费用类型 比较(lt)
   */
  private String feeTypeLt;
  /**
   * 费用类型 比较(lte)
   */
  private String feeTypeLte;
  /**
   * 费用类型 比较(contains)
   */
  private String feeTypeContains;
  /**
   * 费用类型 比较(notcontains)
   */
  private String feeTypeNotcontains;
  /**
   * 费用类型 比较(startswith)
   */
  private String feeTypeStartswith;
  /**
   * 费用类型 比较(endswith)
   */
  private String feeTypeEndswith;
  /**
   * 费用类型 比较(isnull)
   */
  private Boolean feeTypeIsnull;
  /**
   * 费用类型 比较(isnotnull)
   */
  private Boolean feeTypeIsnotnull;

  /**
   * 费用类型(精确搜索)
   */
  private List<String> feeTypeInList;

  /**
   * 费用金额
   */
  private java.math.BigDecimal feeMoney;

  /**
   * 最小费用金额
   */
  private java.math.BigDecimal feeMoneyMin;

  /**
   * 最大费用金额
   */
  private java.math.BigDecimal feeMoneyMax;

  /**
   * 费用金额 比较(eq)
   */
  private java.math.BigDecimal feeMoneyEq;
  /**
   * 费用金额 比较(neq)
   */
  private java.math.BigDecimal feeMoneyNeq;
  /**
   * 费用金额 比较(gt)
   */
  private java.math.BigDecimal feeMoneyGt;
  /**
   * 费用金额 比较(gte)
   */
  private java.math.BigDecimal feeMoneyGte;
  /**
   * 费用金额 比较(lt)
   */
  private java.math.BigDecimal feeMoneyLt;
  /**
   * 费用金额 比较(lte)
   */
  private java.math.BigDecimal feeMoneyLte;
  /**
   * 费用金额 比较(contains)
   */
  private java.math.BigDecimal feeMoneyContains;
  /**
   * 费用金额 比较(notcontains)
   */
  private java.math.BigDecimal feeMoneyNotcontains;
  /**
   * 费用金额 比较(startswith)
   */
  private java.math.BigDecimal feeMoneyStartswith;
  /**
   * 费用金额 比较(endswith)
   */
  private java.math.BigDecimal feeMoneyEndswith;
  /**
   * 费用金额 比较(isnull)
   */
  private Boolean feeMoneyIsnull;
  /**
   * 费用金额 比较(isnotnull)
   */
  private Boolean feeMoneyIsnotnull;

  /**
   * 应付金额
   */
  private java.math.BigDecimal handleMoney;

  /**
   * 最小应付金额
   */
  private java.math.BigDecimal handleMoneyMin;

  /**
   * 最大应付金额
   */
  private java.math.BigDecimal handleMoneyMax;

  /**
   * 应付金额 比较(eq)
   */
  private java.math.BigDecimal handleMoneyEq;
  /**
   * 应付金额 比较(neq)
   */
  private java.math.BigDecimal handleMoneyNeq;
  /**
   * 应付金额 比较(gt)
   */
  private java.math.BigDecimal handleMoneyGt;
  /**
   * 应付金额 比较(gte)
   */
  private java.math.BigDecimal handleMoneyGte;
  /**
   * 应付金额 比较(lt)
   */
  private java.math.BigDecimal handleMoneyLt;
  /**
   * 应付金额 比较(lte)
   */
  private java.math.BigDecimal handleMoneyLte;
  /**
   * 应付金额 比较(contains)
   */
  private java.math.BigDecimal handleMoneyContains;
  /**
   * 应付金额 比较(notcontains)
   */
  private java.math.BigDecimal handleMoneyNotcontains;
  /**
   * 应付金额 比较(startswith)
   */
  private java.math.BigDecimal handleMoneyStartswith;
  /**
   * 应付金额 比较(endswith)
   */
  private java.math.BigDecimal handleMoneyEndswith;
  /**
   * 应付金额 比较(isnull)
   */
  private Boolean handleMoneyIsnull;
  /**
   * 应付金额 比较(isnotnull)
   */
  private Boolean handleMoneyIsnotnull;

  /**
   * 折扣金额
   */
  private java.math.BigDecimal discountAmount;

  /**
   * 最小折扣金额
   */
  private java.math.BigDecimal discountAmountMin;

  /**
   * 最大折扣金额
   */
  private java.math.BigDecimal discountAmountMax;

  /**
   * 折扣金额 比较(eq)
   */
  private java.math.BigDecimal discountAmountEq;
  /**
   * 折扣金额 比较(neq)
   */
  private java.math.BigDecimal discountAmountNeq;
  /**
   * 折扣金额 比较(gt)
   */
  private java.math.BigDecimal discountAmountGt;
  /**
   * 折扣金额 比较(gte)
   */
  private java.math.BigDecimal discountAmountGte;
  /**
   * 折扣金额 比较(lt)
   */
  private java.math.BigDecimal discountAmountLt;
  /**
   * 折扣金额 比较(lte)
   */
  private java.math.BigDecimal discountAmountLte;
  /**
   * 折扣金额 比较(contains)
   */
  private java.math.BigDecimal discountAmountContains;
  /**
   * 折扣金额 比较(notcontains)
   */
  private java.math.BigDecimal discountAmountNotcontains;
  /**
   * 折扣金额 比较(startswith)
   */
  private java.math.BigDecimal discountAmountStartswith;
  /**
   * 折扣金额 比较(endswith)
   */
  private java.math.BigDecimal discountAmountEndswith;
  /**
   * 折扣金额 比较(isnull)
   */
  private Boolean discountAmountIsnull;
  /**
   * 折扣金额 比较(isnotnull)
   */
  private Boolean discountAmountIsnotnull;

  /**
   * 已付金额
   */
  private java.math.BigDecimal actuallyPaid;

  /**
   * 最小已付金额
   */
  private java.math.BigDecimal actuallyPaidMin;

  /**
   * 最大已付金额
   */
  private java.math.BigDecimal actuallyPaidMax;

  /**
   * 已付金额 比较(eq)
   */
  private java.math.BigDecimal actuallyPaidEq;
  /**
   * 已付金额 比较(neq)
   */
  private java.math.BigDecimal actuallyPaidNeq;
  /**
   * 已付金额 比较(gt)
   */
  private java.math.BigDecimal actuallyPaidGt;
  /**
   * 已付金额 比较(gte)
   */
  private java.math.BigDecimal actuallyPaidGte;
  /**
   * 已付金额 比较(lt)
   */
  private java.math.BigDecimal actuallyPaidLt;
  /**
   * 已付金额 比较(lte)
   */
  private java.math.BigDecimal actuallyPaidLte;
  /**
   * 已付金额 比较(contains)
   */
  private java.math.BigDecimal actuallyPaidContains;
  /**
   * 已付金额 比较(notcontains)
   */
  private java.math.BigDecimal actuallyPaidNotcontains;
  /**
   * 已付金额 比较(startswith)
   */
  private java.math.BigDecimal actuallyPaidStartswith;
  /**
   * 已付金额 比较(endswith)
   */
  private java.math.BigDecimal actuallyPaidEndswith;
  /**
   * 已付金额 比较(isnull)
   */
  private Boolean actuallyPaidIsnull;
  /**
   * 已付金额 比较(isnotnull)
   */
  private Boolean actuallyPaidIsnotnull;

  /**
   * 未付金额
   */
  private java.math.BigDecimal unpaidMoney;

  /**
   * 最小未付金额
   */
  private java.math.BigDecimal unpaidMoneyMin;

  /**
   * 最大未付金额
   */
  private java.math.BigDecimal unpaidMoneyMax;

  /**
   * 未付金额 比较(eq)
   */
  private java.math.BigDecimal unpaidMoneyEq;
  /**
   * 未付金额 比较(neq)
   */
  private java.math.BigDecimal unpaidMoneyNeq;
  /**
   * 未付金额 比较(gt)
   */
  private java.math.BigDecimal unpaidMoneyGt;
  /**
   * 未付金额 比较(gte)
   */
  private java.math.BigDecimal unpaidMoneyGte;
  /**
   * 未付金额 比较(lt)
   */
  private java.math.BigDecimal unpaidMoneyLt;
  /**
   * 未付金额 比较(lte)
   */
  private java.math.BigDecimal unpaidMoneyLte;
  /**
   * 未付金额 比较(contains)
   */
  private java.math.BigDecimal unpaidMoneyContains;
  /**
   * 未付金额 比较(notcontains)
   */
  private java.math.BigDecimal unpaidMoneyNotcontains;
  /**
   * 未付金额 比较(startswith)
   */
  private java.math.BigDecimal unpaidMoneyStartswith;
  /**
   * 未付金额 比较(endswith)
   */
  private java.math.BigDecimal unpaidMoneyEndswith;
  /**
   * 未付金额 比较(isnull)
   */
  private Boolean unpaidMoneyIsnull;
  /**
   * 未付金额 比较(isnotnull)
   */
  private Boolean unpaidMoneyIsnotnull;

  /**
   * 申请中
   */
  private java.math.BigDecimal inApplication;

  /**
   * 最小申请中
   */
  private java.math.BigDecimal inApplicationMin;

  /**
   * 最大申请中
   */
  private java.math.BigDecimal inApplicationMax;

  /**
   * 申请中 比较(eq)
   */
  private java.math.BigDecimal inApplicationEq;
  /**
   * 申请中 比较(neq)
   */
  private java.math.BigDecimal inApplicationNeq;
  /**
   * 申请中 比较(gt)
   */
  private java.math.BigDecimal inApplicationGt;
  /**
   * 申请中 比较(gte)
   */
  private java.math.BigDecimal inApplicationGte;
  /**
   * 申请中 比较(lt)
   */
  private java.math.BigDecimal inApplicationLt;
  /**
   * 申请中 比较(lte)
   */
  private java.math.BigDecimal inApplicationLte;
  /**
   * 申请中 比较(contains)
   */
  private java.math.BigDecimal inApplicationContains;
  /**
   * 申请中 比较(notcontains)
   */
  private java.math.BigDecimal inApplicationNotcontains;
  /**
   * 申请中 比较(startswith)
   */
  private java.math.BigDecimal inApplicationStartswith;
  /**
   * 申请中 比较(endswith)
   */
  private java.math.BigDecimal inApplicationEndswith;
  /**
   * 申请中 比较(isnull)
   */
  private Boolean inApplicationIsnull;
  /**
   * 申请中 比较(isnotnull)
   */
  private Boolean inApplicationIsnotnull;

  /**
   * 未申请
   */
  private java.math.BigDecimal notApply;

  /**
   * 最小未申请
   */
  private java.math.BigDecimal notApplyMin;

  /**
   * 最大未申请
   */
  private java.math.BigDecimal notApplyMax;

  /**
   * 未申请 比较(eq)
   */
  private java.math.BigDecimal notApplyEq;
  /**
   * 未申请 比较(neq)
   */
  private java.math.BigDecimal notApplyNeq;
  /**
   * 未申请 比较(gt)
   */
  private java.math.BigDecimal notApplyGt;
  /**
   * 未申请 比较(gte)
   */
  private java.math.BigDecimal notApplyGte;
  /**
   * 未申请 比较(lt)
   */
  private java.math.BigDecimal notApplyLt;
  /**
   * 未申请 比较(lte)
   */
  private java.math.BigDecimal notApplyLte;
  /**
   * 未申请 比较(contains)
   */
  private java.math.BigDecimal notApplyContains;
  /**
   * 未申请 比较(notcontains)
   */
  private java.math.BigDecimal notApplyNotcontains;
  /**
   * 未申请 比较(startswith)
   */
  private java.math.BigDecimal notApplyStartswith;
  /**
   * 未申请 比较(endswith)
   */
  private java.math.BigDecimal notApplyEndswith;
  /**
   * 未申请 比较(isnull)
   */
  private Boolean notApplyIsnull;
  /**
   * 未申请 比较(isnotnull)
   */
  private Boolean notApplyIsnotnull;

  /**
   * 费用录入人
   */
  private Long feeRecorder;

  /**
   * 费用录入人 比较(eq)
   */
  private Long feeRecorderEq;
  /**
   * 费用录入人 比较(neq)
   */
  private Long feeRecorderNeq;
  /**
   * 费用录入人 比较(gt)
   */
  private Long feeRecorderGt;
  /**
   * 费用录入人 比较(gte)
   */
  private Long feeRecorderGte;
  /**
   * 费用录入人 比较(lt)
   */
  private Long feeRecorderLt;
  /**
   * 费用录入人 比较(lte)
   */
  private Long feeRecorderLte;
  /**
   * 费用录入人 比较(contains)
   */
  private Long feeRecorderContains;
  /**
   * 费用录入人 比较(notcontains)
   */
  private Long feeRecorderNotcontains;
  /**
   * 费用录入人 比较(startswith)
   */
  private Long feeRecorderStartswith;
  /**
   * 费用录入人 比较(endswith)
   */
  private Long feeRecorderEndswith;
  /**
   * 费用录入人 比较(isnull)
   */
  private Boolean feeRecorderIsnull;
  /**
   * 费用录入人 比较(isnotnull)
   */
  private Boolean feeRecorderIsnotnull;
  /**
   * 费用录入人的显示用户名 比较(eq)
   */
  private String feeRecorderNameEq;
  /**
   * 费用录入人的显示用户名 比较(neq)
   */
  private String feeRecorderNameNeq;
  /**
   * 费用录入人的显示用户名 比较(gt)
   */
  private String feeRecorderNameGt;
  /**
   * 费用录入人的显示用户名 比较(gte)
   */
  private String feeRecorderNameGte;
  /**
   * 费用录入人的显示用户名 比较(lt)
   */
  private String feeRecorderNameLt;
  /**
   * 费用录入人的显示用户名 比较(lte)
   */
  private String feeRecorderNameLte;
  /**
   * 费用录入人的显示用户名 比较(contains)
   */
  private String feeRecorderNameContains;
  /**
   * 费用录入人的显示用户名 比较(notcontains)
   */
  private String feeRecorderNameNotcontains;
  /**
   * 费用录入人的显示用户名 比较(startswith)
   */
  private String feeRecorderNameStartswith;
  /**
   * 费用录入人的显示用户名 比较(endswith)
   */
  private String feeRecorderNameEndswith;
  /**
   * 费用录入人的显示用户名 比较(isnull)
   */
  private Boolean feeRecorderNameIsnull;
  /**
   * 费用录入人的显示用户名 比较(isnotnull)
   */
  private Boolean feeRecorderNameIsnotnull;

  /**
   * 费用录入人(范围搜索)
   */
  private List<Long> feeRecorderInList;

  /**
   * 最早录入时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date recordTimeStart;

  /**
   * 最晚录入时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date recordTimeEnd;

  /**
   * 录入时间 比较(eq)
   */
  private Date recordTimeEq;
  /**
   * 录入时间 比较(neq)
   */
  private Date recordTimeNeq;
  /**
   * 录入时间 比较(gt)
   */
  private Date recordTimeGt;
  /**
   * 录入时间 比较(gte)
   */
  private Date recordTimeGte;
  /**
   * 录入时间 比较(lt)
   */
  private Date recordTimeLt;
  /**
   * 录入时间 比较(lte)
   */
  private Date recordTimeLte;
  /**
   * 录入时间 比较(contains)
   */
  private Date recordTimeContains;
  /**
   * 录入时间 比较(notcontains)
   */
  private Date recordTimeNotcontains;
  /**
   * 录入时间 比较(startswith)
   */
  private Date recordTimeStartswith;
  /**
   * 录入时间 比较(endswith)
   */
  private Date recordTimeEndswith;
  /**
   * 录入时间 比较(isnull)
   */
  private Boolean recordTimeIsnull;
  /**
   * 录入时间 比较(isnotnull)
   */
  private Boolean recordTimeIsnotnull;

  /**
   * 结算描述(模糊搜索)
   */
  private String describe;

  /**
   * 结算描述 比较(eq)
   */
  private String describeEq;
  /**
   * 结算描述 比较(neq)
   */
  private String describeNeq;
  /**
   * 结算描述 比较(gt)
   */
  private String describeGt;
  /**
   * 结算描述 比较(gte)
   */
  private String describeGte;
  /**
   * 结算描述 比较(lt)
   */
  private String describeLt;
  /**
   * 结算描述 比较(lte)
   */
  private String describeLte;
  /**
   * 结算描述 比较(contains)
   */
  private String describeContains;
  /**
   * 结算描述 比较(notcontains)
   */
  private String describeNotcontains;
  /**
   * 结算描述 比较(startswith)
   */
  private String describeStartswith;
  /**
   * 结算描述 比较(endswith)
   */
  private String describeEndswith;
  /**
   * 结算描述 比较(isnull)
   */
  private Boolean describeIsnull;
  /**
   * 结算描述 比较(isnotnull)
   */
  private Boolean describeIsnotnull;

  /**
   * 结算描述(精确搜索)
   */
  private List<String> describeInList;

  /**
   * 预付比例
   */
  private java.math.BigDecimal budgetRatio;

  /**
   * 最小预付比例
   */
  private java.math.BigDecimal budgetRatioMin;

  /**
   * 最大预付比例
   */
  private java.math.BigDecimal budgetRatioMax;

  /**
   * 预付比例 比较(eq)
   */
  private java.math.BigDecimal budgetRatioEq;
  /**
   * 预付比例 比较(neq)
   */
  private java.math.BigDecimal budgetRatioNeq;
  /**
   * 预付比例 比较(gt)
   */
  private java.math.BigDecimal budgetRatioGt;
  /**
   * 预付比例 比较(gte)
   */
  private java.math.BigDecimal budgetRatioGte;
  /**
   * 预付比例 比较(lt)
   */
  private java.math.BigDecimal budgetRatioLt;
  /**
   * 预付比例 比较(lte)
   */
  private java.math.BigDecimal budgetRatioLte;
  /**
   * 预付比例 比较(contains)
   */
  private java.math.BigDecimal budgetRatioContains;
  /**
   * 预付比例 比较(notcontains)
   */
  private java.math.BigDecimal budgetRatioNotcontains;
  /**
   * 预付比例 比较(startswith)
   */
  private java.math.BigDecimal budgetRatioStartswith;
  /**
   * 预付比例 比较(endswith)
   */
  private java.math.BigDecimal budgetRatioEndswith;
  /**
   * 预付比例 比较(isnull)
   */
  private Boolean budgetRatioIsnull;
  /**
   * 预付比例 比较(isnotnull)
   */
  private Boolean budgetRatioIsnotnull;

  /**
   * 最早预计付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date predictFkTimeStart;

  /**
   * 最晚预计付款时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date predictFkTimeEnd;

  /**
   * 预计付款时间 比较(eq)
   */
  private Date predictFkTimeEq;
  /**
   * 预计付款时间 比较(neq)
   */
  private Date predictFkTimeNeq;
  /**
   * 预计付款时间 比较(gt)
   */
  private Date predictFkTimeGt;
  /**
   * 预计付款时间 比较(gte)
   */
  private Date predictFkTimeGte;
  /**
   * 预计付款时间 比较(lt)
   */
  private Date predictFkTimeLt;
  /**
   * 预计付款时间 比较(lte)
   */
  private Date predictFkTimeLte;
  /**
   * 预计付款时间 比较(contains)
   */
  private Date predictFkTimeContains;
  /**
   * 预计付款时间 比较(notcontains)
   */
  private Date predictFkTimeNotcontains;
  /**
   * 预计付款时间 比较(startswith)
   */
  private Date predictFkTimeStartswith;
  /**
   * 预计付款时间 比较(endswith)
   */
  private Date predictFkTimeEndswith;
  /**
   * 预计付款时间 比较(isnull)
   */
  private Boolean predictFkTimeIsnull;
  /**
   * 预计付款时间 比较(isnotnull)
   */
  private Boolean predictFkTimeIsnotnull;

  /**
   * 支付方式
   */
  private String payType;

  /**
   * 支付方式 比较(eq)
   */
  private String payTypeEq;
  /**
   * 支付方式 比较(neq)
   */
  private String payTypeNeq;
  /**
   * 支付方式 比较(gt)
   */
  private String payTypeGt;
  /**
   * 支付方式 比较(gte)
   */
  private String payTypeGte;
  /**
   * 支付方式 比较(lt)
   */
  private String payTypeLt;
  /**
   * 支付方式 比较(lte)
   */
  private String payTypeLte;
  /**
   * 支付方式 比较(contains)
   */
  private String payTypeContains;
  /**
   * 支付方式 比较(notcontains)
   */
  private String payTypeNotcontains;
  /**
   * 支付方式 比较(startswith)
   */
  private String payTypeStartswith;
  /**
   * 支付方式 比较(endswith)
   */
  private String payTypeEndswith;
  /**
   * 支付方式 比较(isnull)
   */
  private Boolean payTypeIsnull;
  /**
   * 支付方式 比较(isnotnull)
   */
  private Boolean payTypeIsnotnull;

  /**
   * 支付方式(精确搜索)
   */
  private List<String> payTypeInList;

  /**
   * 收款账户名称(模糊搜索)
   */
  private String receiveAccount;

  /**
   * 收款账户名称 比较(eq)
   */
  private String receiveAccountEq;
  /**
   * 收款账户名称 比较(neq)
   */
  private String receiveAccountNeq;
  /**
   * 收款账户名称 比较(gt)
   */
  private String receiveAccountGt;
  /**
   * 收款账户名称 比较(gte)
   */
  private String receiveAccountGte;
  /**
   * 收款账户名称 比较(lt)
   */
  private String receiveAccountLt;
  /**
   * 收款账户名称 比较(lte)
   */
  private String receiveAccountLte;
  /**
   * 收款账户名称 比较(contains)
   */
  private String receiveAccountContains;
  /**
   * 收款账户名称 比较(notcontains)
   */
  private String receiveAccountNotcontains;
  /**
   * 收款账户名称 比较(startswith)
   */
  private String receiveAccountStartswith;
  /**
   * 收款账户名称 比较(endswith)
   */
  private String receiveAccountEndswith;
  /**
   * 收款账户名称 比较(isnull)
   */
  private Boolean receiveAccountIsnull;
  /**
   * 收款账户名称 比较(isnotnull)
   */
  private Boolean receiveAccountIsnotnull;

  /**
   * 收款账户名称(精确搜索)
   */
  private List<String> receiveAccountInList;

  /**
   * 户名(模糊搜索)
   */
  private String userName;

  /**
   * 户名 比较(eq)
   */
  private String userNameEq;
  /**
   * 户名 比较(neq)
   */
  private String userNameNeq;
  /**
   * 户名 比较(gt)
   */
  private String userNameGt;
  /**
   * 户名 比较(gte)
   */
  private String userNameGte;
  /**
   * 户名 比较(lt)
   */
  private String userNameLt;
  /**
   * 户名 比较(lte)
   */
  private String userNameLte;
  /**
   * 户名 比较(contains)
   */
  private String userNameContains;
  /**
   * 户名 比较(notcontains)
   */
  private String userNameNotcontains;
  /**
   * 户名 比较(startswith)
   */
  private String userNameStartswith;
  /**
   * 户名 比较(endswith)
   */
  private String userNameEndswith;
  /**
   * 户名 比较(isnull)
   */
  private Boolean userNameIsnull;
  /**
   * 户名 比较(isnotnull)
   */
  private Boolean userNameIsnotnull;

  /**
   * 户名(精确搜索)
   */
  private List<String> userNameInList;

  /**
   * 开户行(模糊搜索)
   */
  private String bankOfDeposit;

  /**
   * 开户行 比较(eq)
   */
  private String bankOfDepositEq;
  /**
   * 开户行 比较(neq)
   */
  private String bankOfDepositNeq;
  /**
   * 开户行 比较(gt)
   */
  private String bankOfDepositGt;
  /**
   * 开户行 比较(gte)
   */
  private String bankOfDepositGte;
  /**
   * 开户行 比较(lt)
   */
  private String bankOfDepositLt;
  /**
   * 开户行 比较(lte)
   */
  private String bankOfDepositLte;
  /**
   * 开户行 比较(contains)
   */
  private String bankOfDepositContains;
  /**
   * 开户行 比较(notcontains)
   */
  private String bankOfDepositNotcontains;
  /**
   * 开户行 比较(startswith)
   */
  private String bankOfDepositStartswith;
  /**
   * 开户行 比较(endswith)
   */
  private String bankOfDepositEndswith;
  /**
   * 开户行 比较(isnull)
   */
  private Boolean bankOfDepositIsnull;
  /**
   * 开户行 比较(isnotnull)
   */
  private Boolean bankOfDepositIsnotnull;

  /**
   * 开户行(精确搜索)
   */
  private List<String> bankOfDepositInList;

  /**
   * 账户(模糊搜索)
   */
  private String account;

  /**
   * 账户 比较(eq)
   */
  private String accountEq;
  /**
   * 账户 比较(neq)
   */
  private String accountNeq;
  /**
   * 账户 比较(gt)
   */
  private String accountGt;
  /**
   * 账户 比较(gte)
   */
  private String accountGte;
  /**
   * 账户 比较(lt)
   */
  private String accountLt;
  /**
   * 账户 比较(lte)
   */
  private String accountLte;
  /**
   * 账户 比较(contains)
   */
  private String accountContains;
  /**
   * 账户 比较(notcontains)
   */
  private String accountNotcontains;
  /**
   * 账户 比较(startswith)
   */
  private String accountStartswith;
  /**
   * 账户 比较(endswith)
   */
  private String accountEndswith;
  /**
   * 账户 比较(isnull)
   */
  private Boolean accountIsnull;
  /**
   * 账户 比较(isnotnull)
   */
  private Boolean accountIsnotnull;

  /**
   * 账户(精确搜索)
   */
  private List<String> accountInList;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
